Software containers have emerged as an efficient and scalable way to deliver packaged software application code for execution in an isolated environment—also known as operating system virtualization. Typically, a software container is deployed for execution as an independent process running on a server infrastructure (e.g., cloud environment). Each software container includes software elements such as code, runtime, system tools, settings, libraries and the like that enable execution of the underlying application. Examples of currently-available software container projects include Docker™, Open Container Initiative (OCI), and Amazon™ EC2 Containers. These types of cloud-based systems provide fast, horizontal scaling of multiple instances of an application—including the on-the-fly creation of new instances or containers—that can work as a logical unit to ensure availability of the application to end users, especially during periods of increased demand.
In some cases, these cloud-based software applications utilize more traditional backend resources, such as mainframe databases and other services—often in a shared approach, in that multiple instances of a cloud-based software application, or multiple different cloud-based software applications, may rely on the same backend resource. Generally, these types of backend resources—particularly mainframes—operate using a vertical scaling approach, in that additional resources such as CPU, memory and/or disk space are added in order to satisfy expected or sudden increases in demand for resources. However, backend environments are typically static—there are a fixed number of computing devices available to service the application environment, and once the resources of these computing devices have been maximized, additional load from the application environment results in decreased performance and even interruptions in availability of the applications.
Computing environments that comprise a mix of horizontal scaling in the front end and vertical scaling in the back end present some significant technical challenges. As noted above, cloud-based application environments can create a variable number of instances to service end-user demand, and each instance can have its own connection to backend services and data sources as well as each instance managing its own connection management system. Conversely, backend environments generally have a fixed number of computing devices, each of which also has its own connection management. Also, cloud-based application environments generally scale without knowledge of resource availability or resource impact on a shared backend environment—this can be problematic because, while the backend can scale, the computing devices and their hardware resources are eventually finite. In addition, many or all applications and services in the cloud-based application environment can use the same backend resources, while the backend environment is typically not configured to react quickly or adeptly in response to competing demands for scaling from the front end. Finally, scaling decisions on each side—both front-end and back-end—are made locally, which can result in conflicts and unsynchronized scaling.